junebug12851 / pokered-mon-database

 * This module creates an in-memory Pokemon Database for Generation 1 Games

 * It uses a very small memory footprint and speedy-quick navigation

 * This happens through circular references which come with a lot of pitfalls

 *      * Make sure to only keep a single instance of this in memory, Javascript

 *        has a lot of issues with garbage collecting circular references.

 *      * If deep navigating the database, be very careful about not ending up

 *        in infinite loops.

 *      * You cannot use JSON.stringify or certain other tools, at least not

 *        without some careful prep work beforehand

 *

 * This was created initially for the Pokered Save Editor which works just fine

 * with the pitfalls of circular references but for other uses caution may need

 * to be taken.

 */

// Import Dependencies

const _ = require("lodash");

// Import Raw JSON Files

const itemsRaw = require("./data/items.json");

const movesRaw = require("./data/moves.json");

const pokemonRaw = require("./data/pokemon.json");

const typesRaw = require("./data/types.json");

const PokemonDB = exports.PokemonDB = function() {

    this.items = [];

    this.moves = [];

    this.pokemon = [];

    this.types = [];

    this.rebuild();

}

PokemonDB.prototype.rebuild = function() {

    // Setup primary index

    this.indexPrimary(this.itemsRaw, this.items, "ind");

    this.indexPrimary(this.movesRaw, this.moves, "ind");

    this.indexPrimary(this.pokemonRaw, this.pokemon, "ind");

    this.indexPrimary(this.typesRaw, this.types, "ind");

    // Add in aliases for names as-is

    this.indexSecondary(this.itemsRaw, this.items, "name", "ind");

    this.indexSecondary(this.movesRaw, this.moves, "name", "ind");

    this.indexSecondary(this.pokemonRaw, this.pokemon, "name", "ind");

    this.indexSecondary(this.typesRaw, this.types, "name", "ind");

    // Add in aliases for names in snake_case form

    this.indexSecondarySnake(this.itemsRaw, this.items, "name", "ind");

    this.indexSecondarySnake(this.movesRaw, this.moves, "name", "ind");

    this.indexSecondarySnake(this.pokemonRaw, this.pokemon, "name", "ind");

    this.indexSecondarySnake(this.typesRaw, this.types, "name", "ind");

    // Add in aliases prefixed

    this.indexSecondaryPrefix(this.itemsRaw, this.items, "tm", "ind");

    this.indexSecondaryPrefix(this.itemsRaw, this.items, "hm", "ind");

    this.indexSecondaryPrefix(this.movesRaw, this.moves, "tm", "ind");

    this.indexSecondaryPrefix(this.movesRaw, this.moves, "hm", "ind");

    this.indexSecondaryPrefix(this.pokemonRaw, this.pokemon, "pokedex", "ind");

    // Circular Link everything

    // Yes I'm aware of the dangers and pitfalls of circular linking

    // I'm choosing it anyways

    this.process2Items();

    this.process2Moves();

    this.process2Pokemon();

}

// Indexes all items by deep cloning each item and adding it to the object under key value

PokemonDB.prototype.indexPrimary = function(from, to, key) {

    for(let i = 0; i < from.length; i++) {

        const entry = from[i];

        to[entry[key]] = _.cloneDeep(entry);

    }

}

// Creates a 2nd index which just aliases the first index

PokemonDB.prototype.indexSecondary = function(from, to, key, origKey) {

    for(let i = 0; i < from.length; i++) {

        const entry = from[i];

        to[entry[key]] = to[entry[origKey]];

    }

}

// Creates a 2nd index snake_case'd which just aliases the first index

PokemonDB.prototype.indexSecondarySnake = function(from, to, key, origKey) {

    for(let i = 0; i < from.length; i++) {

        const entry = from[i];

        to[_.snakeCase(entry[key])] = to[entry[origKey]];

    }

}

// Creates a 2nd index prefixed which just aliases the first index

// Only creates alias if key exists

PokemonDB.prototype.process2Items = function() {

    const self = this;

    _.each(self.items, function(value) {

        if(value.tm !== undefined && value._tm === undefined) {

            value._tm = value.tm;

            value.tm = _.find(self.moves, ['tm', value.tm]);

        }

        if(value.hm !== undefined && value._hm === undefined) {

            value._hm = value.hm;

            value.hm = _.find(self.moves, ['hm', value.hm]);

        }

    });

}

PokemonDB.prototype.process2Moves = function() {

    const self = this;

    _.each(self.moves, function(value) {

        if(value.type !== undefined && value._type === undefined) {

            value._type = value.type;

            value.type = _.find(self.types, ['name', value.type]);

        }

        if(value.tm !== undefined && value._tm === undefined) {

            value._tm = value.tm;

            value.tm = _.find(self.items, ['_tm', value.tm]);

        }

        if(value.hm !== undefined && value._hm === undefined) {

            value._hm = value.hm;

            value.hm = _.find(self.items, ['_hm', value.hm]);

        }

    });

}

PokemonDB.prototype.process2Pokemon = function() {

    const self = this;

    _.each(self.pokemon, function(value) {

        if(value.moves !== undefined) {

            for(let i = 0; i < value.moves.length; i++) {

                const move = value.moves[i];

                if(move._move !== undefined)

                move._move = move.move;

                move.move = _.find(self.moves, ['name',move.move]);

            }

        }

        self._processMoveList(value, "initial", "name", self);

        self._processMoveList(value, "tmHm", "_tm", self);

        if(value.type1 !== undefined && value._type1 === undefined) {

            value._type1 = value.type1;

            value.type1 = _.find(self.types, ['name', value.type1]);

        }

        if(value.type2 !== undefined && value._type2 === undefined) {

            value._type2 = value.type2;

            value.type2 = _.find(self.types, ['name', value.type2]);

        }

        if(value.evolution !== undefined) {

            if(Array.isArray(value.evolution)) {

                for(let i = 0; i < value.evolution.length; i++) {

                    self._processEvolutionEntry(value.evolution[i], value, self);

                }

            }

            else

        }

    });

}

PokemonDB.prototype._processMoveList = function(value, from, key, self) {

    if(value[from] !== undefined && value['_' + from] === undefined) {

        value['_' + from] = _.cloneDeep(value[from]);

        for(let i = 0; i < value[from].length; i++) {

            const val = value[from][i];

            value[from][i] = _.find(self.moves, [key, val]);

        }

    }

}

PokemonDB.prototype._processEvolutionEntry = function(entry, value, self) {

    if(entry.item !== undefined && entry._item === undefined) {

        entry._item = entry.item;

        entry.item = _.find(self.items, ['name', entry.item]);

    }

    if(entry._toName !== undefined)

    entry._toName = entry.toName;

    entry.toName = _.find(self.pokemon, ['name', entry.toName]);

    entry.toName.deEvolution = value;

}

// Add several ways to access the raw data, nothings duplicated because it's just all copying

// by reference

PokemonDB.itemsRaw = PokemonDB.prototype.itemsRaw = itemsRaw;

PokemonDB.movesRaw = PokemonDB.prototype.movesRaw = movesRaw;

PokemonDB.typesRaw = PokemonDB.prototype.typesRaw = typesRaw;

PokemonDB.pokemonRaw = PokemonDB.prototype.pokemonRaw = pokemonRaw;